Computer systems often include one or more general purpose processors (e.g., central processing units (CPUs)) and one or more specialized data parallel compute nodes (e.g., graphics processing units (GPUs) or single instruction, multiple data (SIMD) execution units in CPUs). General purpose processors generally perform general purpose processing on computer systems, and data parallel compute nodes generally perform data parallel processing (e.g., graphics processing) on computer systems. General purpose processors often have the ability to implement data parallel algorithms but do so without the optimized hardware resources found in data parallel compute nodes. As a result, general purpose processors may be far less efficient in executing data parallel algorithms than data parallel compute nodes.
Data parallel compute nodes have traditionally played a supporting role to general purpose processors in executing programs on computer systems. As the role of hardware optimized for data parallel algorithms increases due to enhancements in data parallel compute node processing capabilities, it would be desirable to enhance the ability of programmers to program data parallel compute nodes and make the programming of data parallel compute nodes easier.
Data parallel algorithms are often executed on data parallel compute nodes, viz., foreign compute nodes, that have different memory hierarchies than a host compute node. With different memory hierarchies, foreign compute nodes may need to invoke complicated synchronization protocols when reading data in memory that may be updated by the host or other foreign compute nodes. If the data could be made read-only (i.e., the data may be read by one or more compute nodes but may not be written by any compute node), the synchronization protocols may be avoided.
Unfortunately, high level programming languages such C and C++ do not provide a mechanism that assures that data can be made read-only. In particular, the concept of read-only in C++ maps to the const modifier which may be ignored and casted away by programmers. In addition, a top-level const modifier may not be useful inside function calls because the function signature discards top-level cv-qualifiers (e.g., foo(const field f) is stored as foo(field f)). Further, a constant may be assigned to a non-constant—e.g., const field f; field g=f—by a programmer.